
package com.tivyso.testing.mock.generator;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConstructorArgumentValues;

public class BeanDefinitionMock
    implements BeanDefinition
{

    private String fieldBeanClassName;
    private boolean fieldBeanClassNameConfigured = false;
    private String fieldResourceDescription;
    private boolean fieldResourceDescriptionConfigured = false;
    private String fieldParentName;
    private boolean fieldParentNameConfigured = false;
    private String fieldFactoryBeanName;
    private boolean fieldFactoryBeanNameConfigured = false;
    private String fieldFactoryMethodName;
    private boolean fieldFactoryMethodNameConfigured = false;
    private String fieldScope;
    private boolean fieldScopeConfigured = false;
    private boolean fieldIsLazyInit;
    private boolean fieldIsLazyInitConfigured = false;
    private String[] fieldDependsOn;
    private boolean fieldDependsOnConfigured = false;
    private boolean fieldIsAutowireCandidate;
    private boolean fieldIsAutowireCandidateConfigured = false;
    private boolean fieldIsPrimary;
    private boolean fieldIsPrimaryConfigured = false;
    private ConstructorArgumentValues fieldConstructorArgumentValues;
    private boolean fieldConstructorArgumentValuesConfigured = false;
    private MutablePropertyValues fieldPropertyValues;
    private boolean fieldPropertyValuesConfigured = false;
    private boolean fieldIsSingleton;
    private boolean fieldIsSingletonConfigured = false;
    private boolean fieldIsPrototype;
    private boolean fieldIsPrototypeConfigured = false;
    private int fieldRole;
    private boolean fieldRoleConfigured = false;
    private BeanDefinition fieldOriginatingBeanDefinition;
    private boolean fieldOriginatingBeanDefinitionConfigured = false;
    private boolean fieldIsAbstract;
    private boolean fieldIsAbstractConfigured = false;
    private String fieldDescription;
    private boolean fieldDescriptionConfigured = false;
    private String[] fieldAttributeNames;
    private boolean fieldAttributeNamesConfigured = false;
    private Object fieldSource;
    private boolean fieldSourceConfigured = false;

    private BeanDefinitionMock() {
    }

    public static BeanDefinitionMock create() {
        return new BeanDefinitionMock();
    }

    public BeanDefinitionMock withBeanClassName(String fieldBeanClassNameParam) {
        fieldBeanClassName = fieldBeanClassNameParam;
        fieldBeanClassNameConfigured = true;
        return this;
    }

    public String getBeanClassName() {
        if (!fieldBeanClassNameConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getBeanClassName");
        }
        return this.fieldBeanClassName;
    }

    public BeanDefinitionMock withResourceDescription(String fieldResourceDescriptionParam) {
        fieldResourceDescription = fieldResourceDescriptionParam;
        fieldResourceDescriptionConfigured = true;
        return this;
    }

    public String getResourceDescription() {
        if (!fieldResourceDescriptionConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getResourceDescription");
        }
        return this.fieldResourceDescription;
    }

    public BeanDefinitionMock withParentName(String fieldParentNameParam) {
        fieldParentName = fieldParentNameParam;
        fieldParentNameConfigured = true;
        return this;
    }

    public String getParentName() {
        if (!fieldParentNameConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getParentName");
        }
        return this.fieldParentName;
    }

    public void setParentName(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setParentName");
    }

    public void setBeanClassName(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setBeanClassName");
    }

    public BeanDefinitionMock withFactoryBeanName(String fieldFactoryBeanNameParam) {
        fieldFactoryBeanName = fieldFactoryBeanNameParam;
        fieldFactoryBeanNameConfigured = true;
        return this;
    }

    public String getFactoryBeanName() {
        if (!fieldFactoryBeanNameConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getFactoryBeanName");
        }
        return this.fieldFactoryBeanName;
    }

    public void setFactoryBeanName(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setFactoryBeanName");
    }

    public BeanDefinitionMock withFactoryMethodName(String fieldFactoryMethodNameParam) {
        fieldFactoryMethodName = fieldFactoryMethodNameParam;
        fieldFactoryMethodNameConfigured = true;
        return this;
    }

    public String getFactoryMethodName() {
        if (!fieldFactoryMethodNameConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getFactoryMethodName");
        }
        return this.fieldFactoryMethodName;
    }

    public void setFactoryMethodName(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setFactoryMethodName");
    }

    public BeanDefinitionMock withScope(String fieldScopeParam) {
        fieldScope = fieldScopeParam;
        fieldScopeConfigured = true;
        return this;
    }

    public String getScope() {
        if (!fieldScopeConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getScope");
        }
        return this.fieldScope;
    }

    public void setScope(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setScope");
    }

    public BeanDefinitionMock withIsLazyInit(boolean fieldIsLazyInitParam) {
        fieldIsLazyInit = fieldIsLazyInitParam;
        fieldIsLazyInitConfigured = true;
        return this;
    }

    public boolean isLazyInit() {
        if (!fieldIsLazyInitConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.isLazyInit");
        }
        return this.fieldIsLazyInit;
    }

    public void setLazyInit(boolean arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setLazyInit");
    }

    public BeanDefinitionMock withDependsOn(String[] fieldDependsOnParam) {
        fieldDependsOn = fieldDependsOnParam;
        fieldDependsOnConfigured = true;
        return this;
    }

    public String[] getDependsOn() {
        if (!fieldDependsOnConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getDependsOn");
        }
        return this.fieldDependsOn;
    }

    public void setDependsOn(String[] arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setDependsOn");
    }

    public BeanDefinitionMock withIsAutowireCandidate(boolean fieldIsAutowireCandidateParam) {
        fieldIsAutowireCandidate = fieldIsAutowireCandidateParam;
        fieldIsAutowireCandidateConfigured = true;
        return this;
    }

    public boolean isAutowireCandidate() {
        if (!fieldIsAutowireCandidateConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.isAutowireCandidate");
        }
        return this.fieldIsAutowireCandidate;
    }

    public void setAutowireCandidate(boolean arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setAutowireCandidate");
    }

    public BeanDefinitionMock withIsPrimary(boolean fieldIsPrimaryParam) {
        fieldIsPrimary = fieldIsPrimaryParam;
        fieldIsPrimaryConfigured = true;
        return this;
    }

    public boolean isPrimary() {
        if (!fieldIsPrimaryConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.isPrimary");
        }
        return this.fieldIsPrimary;
    }

    public void setPrimary(boolean arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setPrimary");
    }

    public BeanDefinitionMock withConstructorArgumentValues(ConstructorArgumentValues fieldConstructorArgumentValuesParam) {
        fieldConstructorArgumentValues = fieldConstructorArgumentValuesParam;
        fieldConstructorArgumentValuesConfigured = true;
        return this;
    }

    public ConstructorArgumentValues getConstructorArgumentValues() {
        if (!fieldConstructorArgumentValuesConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getConstructorArgumentValues");
        }
        return this.fieldConstructorArgumentValues;
    }

    public BeanDefinitionMock withPropertyValues(MutablePropertyValues fieldPropertyValuesParam) {
        fieldPropertyValues = fieldPropertyValuesParam;
        fieldPropertyValuesConfigured = true;
        return this;
    }

    public MutablePropertyValues getPropertyValues() {
        if (!fieldPropertyValuesConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getPropertyValues");
        }
        return this.fieldPropertyValues;
    }

    public BeanDefinitionMock withIsSingleton(boolean fieldIsSingletonParam) {
        fieldIsSingleton = fieldIsSingletonParam;
        fieldIsSingletonConfigured = true;
        return this;
    }

    public boolean isSingleton() {
        if (!fieldIsSingletonConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.isSingleton");
        }
        return this.fieldIsSingleton;
    }

    public BeanDefinitionMock withIsPrototype(boolean fieldIsPrototypeParam) {
        fieldIsPrototype = fieldIsPrototypeParam;
        fieldIsPrototypeConfigured = true;
        return this;
    }

    public boolean isPrototype() {
        if (!fieldIsPrototypeConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.isPrototype");
        }
        return this.fieldIsPrototype;
    }

    public BeanDefinitionMock withRole(int fieldRoleParam) {
        fieldRole = fieldRoleParam;
        fieldRoleConfigured = true;
        return this;
    }

    public int getRole() {
        if (!fieldRoleConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getRole");
        }
        return this.fieldRole;
    }

    public BeanDefinitionMock withOriginatingBeanDefinition(BeanDefinition fieldOriginatingBeanDefinitionParam) {
        fieldOriginatingBeanDefinition = fieldOriginatingBeanDefinitionParam;
        fieldOriginatingBeanDefinitionConfigured = true;
        return this;
    }

    public BeanDefinition getOriginatingBeanDefinition() {
        if (!fieldOriginatingBeanDefinitionConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getOriginatingBeanDefinition");
        }
        return this.fieldOriginatingBeanDefinition;
    }

    public BeanDefinitionMock withIsAbstract(boolean fieldIsAbstractParam) {
        fieldIsAbstract = fieldIsAbstractParam;
        fieldIsAbstractConfigured = true;
        return this;
    }

    public boolean isAbstract() {
        if (!fieldIsAbstractConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.isAbstract");
        }
        return this.fieldIsAbstract;
    }

    public BeanDefinitionMock withDescription(String fieldDescriptionParam) {
        fieldDescription = fieldDescriptionParam;
        fieldDescriptionConfigured = true;
        return this;
    }

    public String getDescription() {
        if (!fieldDescriptionConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getDescription");
        }
        return this.fieldDescription;
    }

    public Object getAttribute(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getAttribute");
    }

    public Object removeAttribute(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.removeAttribute");
    }

    public void setAttribute(String arg0, Object arg1) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.setAttribute");
    }

    public boolean hasAttribute(String arg0) {
        throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.hasAttribute");
    }

    public BeanDefinitionMock withAttributeNames(String[] fieldAttributeNamesParam) {
        fieldAttributeNames = fieldAttributeNamesParam;
        fieldAttributeNamesConfigured = true;
        return this;
    }

    public String[] attributeNames() {
        if (!fieldAttributeNamesConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.attributeNames");
        }
        return this.fieldAttributeNames;
    }

    public BeanDefinitionMock withSource(Object fieldSourceParam) {
        fieldSource = fieldSourceParam;
        fieldSourceConfigured = true;
        return this;
    }

    public Object getSource() {
        if (!fieldSourceConfigured) {
            throw new UnsupportedOperationException("No mocked behaviour was specified for BeanDefinitionMock.getSource");
        }
        return this.fieldSource;
    }

}
